library(tidyverse)
library(skimr)
library(rethinking)

Notes

Introduction

Linear regression describes a measurements mean and variance as the addition of other measurements. It assumes the errors in the primary measurement are of the gaussian distribution.

Normality

1000 individuals conduct a random walk on either side of the football field starting at the 50 yard line (value = 0). This signifies the normal distribution.

INDIVIDUALS <- 1000
TRIALS <- 100

purrr::map(1:INDIVIDUALS, ~ runif(TRIALS, -1, 1)) %>% 
  purrr::map(cumsum) %>% 
  reduce(rbind) %>% 
  as_tibble %>% 
  `colnames<-`(paste0(1:TRIALS, "t")) %>% 
  mutate(individual = row_number()) %>% 
  reshape2::melt("individual") %>% 
  arrange(individual, variable) %>% 
  ggplot(aes(x=variable, y=value, group=individual)) + 
    geom_line(alpha = I(1/20), size=1) +
    geom_boxplot(aes(x=variable, y = value), inherit.aes = FALSE, colour = "yellow", alpha= I(1/40))

The above example shows us that normality is additive.

# Generate 12 numbers between 1 and 1.1 then add them in to one sum
# Do this 1000 times and collect the numbers in a vector
growth <- replicate(1000, sum(runif(12,0,.1)))
# Plot the distribution of thes enumbers. Note that it is normal.
qplot(growth)

We can also show that normality is multiplicative.

# Generate 12 numbers between 1 and 1.1 then multiply them in to one product
# Do this 1000 times and collect the numbers in a vector
growth <- replicate(1000, prod(1 + runif(12,0,.1)))
#plot the distribution of these numbers. Note that it is normal.
qplot(INDIVIDUALS)

Things start to skew at very large deviates, though this can be corrected by log scaling.

big <- replicate(10000, prod(1 + runif(12, 0, .5)))
small <- replicate(10000, prod(1 + runif(12, 0, 0.01)))

data_frame(big = big, 
           small = small, 
           log_big = log(big)) %>% 
  gather %>% 
  ggplot(aes(value)) + 
    geom_histogram() + 
    facet_wrap("key", scales = "free")

A language for describing models

Elements:

An outcome variable: The set of measurements we hope to predict or understand
Likeliehood distribution: For each of these outcome variables, we define the plausibility of that observations.
Predictor variables: Set of other measurements that we hope to use to predict or understand the outcome.

Approach:

Relate the exact shape of the likelihood distribution to the predictor variables via parameters
Choose priors for all the parameters in the model.

Example: A gaussian model of height

We’ll build a regression to predict a human’s hight, which we will model as a Gaussian distribution with two parameters, mean and standard deviation. There are an infinite number of possible Gaussian distributions. We want our Bayesian machine to consider every possible distribution, each defined by a combination of meand and sd, and rank them by posterior plausibility given the data.

data(Howell1)
d <- Howell1
d2 <- d %>% 
  filter(age >= 18)
d2 %>% 
  skim

Skim summary statistics
 n obs: 352 
 n variables: 4 

── Variable type:integer ────────────────────────────────────────────────────────────
 variable missing complete   n mean  sd p0 p25 p50 p75 p100     hist
     male       0      352 352 0.47 0.5  0   0   0   1    1 ▇▁▁▁▁▁▁▇

── Variable type:numeric ────────────────────────────────────────────────────────────
 variable missing complete   n   mean    sd     p0    p25    p50    p75   p100
      age       0      352 352  41.14 15.97  18     28     39     51     88   
   height       0      352 352 154.6   7.74 136.53 148.59 154.31 160.66 179.07
   weight       0      352 352  44.99  6.46  31.07  40.26  44.79  49.29  62.99
     hist
 ▇▇▇▅▂▃▁▁
 ▁▅▇▆▆▃▁▁
 ▂▆▇▇▇▃▂▁

Lets specifiy our model like so. The first line is the likelihood of our outcome, height. The second two lines are priors for the parameters in our likelihood. \[ h_i \sim Normal(\mu, \sigma) \\ \mu \sim Normal(178, 20) \\ \sigma \sim Uniform(0, 50) \]

As height is a physical phenomenon, we can use our intuition to assign a prior.

data_frame(x=100:250, 
           y=purrr::map_dbl(100:250, ~ dnorm(.x, 178, 20))) %>% 
  ggplot(aes(x,y)) + geom_path()

We give the standard deviation a truly flat prior. We really just want to make sure its positive.

data_frame(x=-10:60, 
           y=purrr::map_dbl(-10:60, ~ dunif(.x, 0, 50))) %>% 
  ggplot(aes(x,y)) + geom_path()

Specifying a prior for the parameters of our outcome implicitly give us a prior for our outcome.

sample_mu <- rnorm(1e4, 178, 20)
sample_sigma <- runif(1e4, 0, 50)
prior_h <- rnorm(1e4, sample_mu, sample_sigma)
qplot(prior_h)

Lets us grid approximation to generate the posterior. To do so, we enumerate a list of candidate values for our parameters and store them in post. We then calculate the log likelihood for each of those parameters given all the heights we have seen and store them in the column LL. We use log transformation to avoid rounding errors. Then we multiply by the priors (log addition is the same as multiplying)

# Generate candidate parameters
mu_list <- seq(from=140, to=160, length.out=200)
sigma_list <- seq(from=4, to=9, length.out=200)
post <- expand.grid(mu=mu_list, sigma=sigma_list)

# Calculate the likelihood of every possible
# combination candidate parameters
post$LL <- sapply(1:nrow(post), function(i) {
  sum(dnorm(
    d2$height,
    mean=post$mu[i],
    sd=post$sigma[i],
    log=TRUE))
  })

# Multiply priors
post$prod <- post$LL + dnorm(post$mu, 178, 20, TRUE) +
  dunif(post$sigma, 0, 50, TRUE)

# Calculated scaled posterior
post$prob <- exp(post$prod - max(post$prod))

# Contour plot of probabilities
ggplot(post, aes(x=mu, y=sigma, z=prob)) + 
  geom_contour(aes(colour=stat(level))) + 
  coord_cartesian(xlim=c(140, 160), ylim=c(4, 9))

Now lets sample from the posterior.

# Sample candidate values by posterior
sample_rows <- sample(1:nrow(post), size=1e4, replace=TRUE, prob=post$prob)

# Plot their 2d histogram
data_frame(
  sample_mu = post$mu[sample_rows],
  sample_sigma = post$sigma[sample_rows]
) %>% 
  ggplot(aes(sample_mu, sample_sigma)) +
    geom_bin2d(bins=30) + 
    coord_cartesian(xlim=c(140, 160), ylim=c(4, 9))

Lets also examine the margins.

require(gridExtra)

Loading required package: gridExtra

Attaching package: ‘gridExtra’

The following object is masked from ‘package:dplyr’:

    combine

p1 <- post$mu[sample_rows] %>% 
  qplot + ggtitle("mu")
p2 <- post$sigma[sample_rows] %>% 
  qplot + ggtitle("sigma")

grid.arrange(p1, p2, ncol=2)

map from the rethinking package allows us to solve for the posterior using quadratic approximation instead of grid approximations. It shows us gaussian approximations for each parameter’s marginal distribution.

flist <- alist(
  height ~ dnorm(mu, sigma),
  mu ~ dnorm(178, 20),
  sigma ~ dunif(0, 50)
)
m4.1 <- rethinking::map(flist, data=d2)
precis(m4.1)

Variance covariance matrix tells us how each parameter relates to every other parameter in the posterior distribution.

vcov(m4.1)

                mu        sigma
mu    0.1697392273 0.0002182711
sigma 0.0002182711 0.0849053439

# This can be factored in to a vector of variances
diag(vcov(m4.1))

        mu      sigma 
0.16973923 0.08490534

# Or a correlation matrix
cov2cor(vcov(m4.1))

               mu       sigma
mu    1.000000000 0.001818183
sigma 0.001818183 1.000000000

Lets draw from the posterior by sampling vectors of values from a multi-dimensional gaussian distribution.

post <- extract.samples(m4.1, n=1e4)
precis(post)

quap posterior: 10000 samples from m4.1

Adding a predictor variable, weight

It looks like weight will be a good predictor for height in adults.

ggplot(d2, aes(x=weight, y=height)) + 
  geom_point(shape=1) +
  geom_smooth(method=lm)

The goal here is to make the parameter for the mean of a Gaussian distribution, \(\mu\), into a linear function of the predictor variable. This encodes the assumption that the predictor variable has a perfectly constant and additive relationship to the mean of the outcome.

m4.3 <- rethinking::map(
  alist(
    height ~ dnorm(mu, sigma),
    mu <- a + b*weight,
    a ~ dnorm(156, 100),
    b ~ dnorm(0, 10),
    sigma ~ dunif(0, 50)),
  data = d2)
# Display table of estimates
precis(m4.3, corr=TRUE)

The table above tells us that a person 1 kg heavier is expected to be .9 cm taller. It also tells us that a person with 0 weight is 114 cm tall, which is of course nonsense; This is why it is usually important to have very weak priors for intercepts in many cases. Finally, it explains that 95% of plausible heights lie within 10 cm of the mean.

Centering is the procedure of subtracting the mean of a variable from each value.

d2$weight.c <- d2$weight - mean(d2$weight)

m4.4 <- rethinking::map(
  alist(
    height ~ dnorm(mu, sigma),
    mu <- a + b*weight.c,
    a ~ dnorm(178, 100),
    b ~ dnorm(0, 10),
    sigma ~ dunif(0, 50)),
  data = d2)
# Display table of estimates
precis(m4.4, corr=TRUE)

By centering our predictor variable, the interpretation of the intercept has now become the expected value of the outcome when the predictor is at its average value. This makes interpreting the intercept a lot easier.

Visualizing our estimates

We can plot our maximum a posteriori fit here

p <- ggplot(d2, aes(x=weight, y=height)) +
  geom_point(shape=1, size=2) +
  geom_abline(aes(intercept = coef(m4.3)["a"],
                  slope = coef(m4.3)["b"]))
p

This line only represents one piece of the posterior. We could instead sample values of \(\alpha\) and \(\beta\) from the posterior to generate many lines to build bounds of uncertainty. We’ll do this with a much smaller dataset to magnify effects.

N <- 10
dN <- d2[ 1:N , ]
mN <- rethinking::map(
  alist(
    height ~ dnorm( mu , sigma ) ,
    mu <- a + b*weight ,
    a ~ dnorm( 178 , 100 ) ,
    b ~ dnorm( 0 , 10 ) ,
    sigma ~ dunif( 0 , 50 )
) , data=dN )

post <- extract.samples(mN, n=20)
head(post)

p <- ggplot(dN, aes(weight, height)) +
  geom_point(shape=1)

for (i in 1:20) {
  p <- p + geom_abline(intercept = post$a[i], slope = post$b[i], alpha = I(3/10))
}

p

To do this more generally:

Sample parameter values from the posterior.
Use the parameter values to create predictions of the parameters of interest, including the final outcome.
Use summary functions like mean, HDOP, PI to find averages and lower and upper bounds of our uncertainty.

# Draw parameter values from the posterior distribution
posterior_samples <- extract.samples(m4.3)

# Create out x-axis of interest
weights_axis <- 25:70

# Function to calculate fit values for \mu
mu_link <- function(weight) post$a + post$b*weight
mu <- purrr::map(weights_axis, mu_link)

# Function to calculate fit heights
# This incorporates variability as well
simulate <- function(weight, parameter_samples) {
  rnorm(n = nrow(parameter_samples),
        mean = parameter_samples$a + parameter_samples$b * weight,
        sd = parameter_samples$sigma)}
simulated_heights <- purrr::map(weights_axis, ~ simulate(.x, posterior_samples))

# Combine all this information to plot
data_frame(
  # X axis
  weight = weights_axis,
  # Estimates for mean height
  mu_mean = map_dbl(mu, mean),
  mu_lower = map_dbl(mu, ~HPDI(.x, .89)[1]),
  mu_upper = map_dbl(mu, ~HPDI(.x, .89)[2]),
  # Estimates for height
  height_mean = map_dbl(simulated_heights, mean),
  height_low = map_dbl(simulated_heights, ~HPDI(.x, .89)[1]),
  height_high = map_dbl(simulated_heights, ~HPDI(.x, .89)[2])) %>% 
  ggplot(data=.) +
  geom_point(inherit.aes = FALSE, data = d2,
             aes(x=weight, y=height), shape=1) +
  geom_line(aes(x=weight, y=mu_mean)) +
  geom_ribbon(aes(x = weight, ymin=mu_lower, ymax=mu_upper), alpha=.5) +
  geom_ribbon(aes(x = weight, ymin = height_low, ymax = height_high), alpha=.3) +
  ggtitle("The effect of weight on height", subtitle = "Using 89% highest posterior density intervals") +
  coord_cartesian(xlim=c(30, 60),ylim=c(135, 180))

Polynomial Regression

Standardizing our predictors means scaling but also dividing by the standard deviation. This changes our interpretation of continuous variables to mean the unit change in outcome from a cahnge of one standard deviation.

# Standardize continuous variable
standardize <- function(vec) {
  centered <- vec - mean(vec)
  centered / sd(vec)
}
d$weight.s <- standardize(d$weight)

# Define another polynomial term
d$weight.s2 <- d$weight.s^2

m4.5 <- map(
  alist(
    # Outcome
    height ~ dnorm(mu, sigma),
    # Regression specification
    mu <- a + b1*weight.s + b2*weight.s2,
    a ~ dnorm(178 , 100),
    # These priors are very weak!
    b1 ~ dnorm(0 , 10),
    b2 ~ dnorm(0 , 10),
    sigma ~ dunif(0 , 50)),
  data=d )
precis( m4.5 )

B-Splines

Splines are an alternative to modeling non-linearity. We’ll show this with some cherry blossom data.

library(rethinking)
library(rcartocolor)
colour_theme <- "BurgYl"
palette <- carto_pal(7, colour_theme)

data(cherry_blossoms)
d <- cherry_blossoms

d %>% 
  select(year, temp) %>% 
  ggplot(aes(year, temp)) +
    geom_line(colour = palette[7]) +
    theme_burgyl()

NA

Splines work by defining knot points and fitting local models between them. A common way to pick these knot points is to evenly space them across the probability density of the variable. Cross validation can ultimately be used to validate the number and spacing.

d2 <- d %>% 
  filter(!is.na(temp))
num_knots <- 15
knot_list <- quantile(d2$year, probs = seq(0, 1, length.out = num_knots))
d2 %>% 
  ggplot(aes(year)) +
  geom_density(colour = "transparent", fill = palette[5]) +
  geom_point(data = data_frame(y= rep(0, length(knot_list)), x=knot_list),
             mapping = aes(x, y), 
             size = 3, colour = palette[7]) +
  theme_burgyl() + ggtitle("Knot point allocation")

Now we pick the polynomial degree. This determines how many basis parameters at once are interacting with a given point. The splines library in R can help us with this. The code below will create 17 columns in place of year that result from its change of basis.

posterior_summary(fit.spline)

                 Estimate   Est.Error         Q2.5        Q97.5
b_Intercept    6.32232353 0.239223616    5.8391272    6.7829623
b_year_1       0.09842464 0.260051555   -0.4001889    0.6075442
b_year_2       0.24137556 0.275882205   -0.3072947    0.7821862
b_year_3       1.19993220 0.269603691    0.6743946    1.7293925
b_year_4      -0.82019659 0.255732821   -1.3066008   -0.3167264
b_year_5       0.10171999 0.254785921   -0.4080378    0.6020521
b_year_6      -1.40488733 0.252521101   -1.8872237   -0.8965606
b_year_7       1.15627188 0.255715220    0.6617547    1.6692874
b_year_8      -1.91663644 0.250916348   -2.4033165   -1.4195968
b_year_9       2.34684446 0.254658438    1.8454632    2.8576482
b_year_10     -2.31889187 0.252143992   -2.8041959   -1.8086396
b_year_11      0.93339356 0.254833356    0.4261467    1.4416483
b_year_12     -1.61366922 0.254398401   -2.1167049   -1.1142676
b_year_13      0.17894803 0.253669626   -0.3172705    0.6873232
b_year_14     -1.24132292 0.256076052   -1.7392509   -0.7453285
b_year_15      0.03278374 0.268382189   -0.4885031    0.5606930
b_year_16      0.99338364 0.270930809    0.4639197    1.5279240
b_year_17      2.03762622 0.265267132    1.5035638    2.5580490
sigma          0.34736003 0.007543462    0.3330691    0.3622407
lp__        -441.28700233 3.153867138 -448.2382129 -436.2200223

Extract the predicted means and the error term.

mu = as_data_frame(fitted(fit.spline))
temp_hat = as_data_frame(predict(fit.spline))

(dimensions <- list(mu = dim(mu), 
                   temp_hat = dim(temp_hat)))

$mu
[1] 1124    4

$temp_hat
[1] 1124    4

Plot the posterior predictions.

data_frame(
  temp = filter(d, !is.na(temp))$temp,
  year = filter(d, !is.na(temp))$year,
  temp_mu = mu$Estimate,
  temp_mu_lb = mu$Q2.5,
  temp_mu_ub = mu$Q97.5,
  temp_hat_p = temp_hat$Estimate,
  temp_hat_lb = temp_hat$Q2.5,
  temp_hat_ub = temp_hat$Q97.5) %>% 
  ggplot(aes(x = year, y = temp)) +
    geom_jitter(alpha = .4, colour = palette[6]) +
    geom_ribbon(aes(ymin = temp_mu_lb, ymax = temp_mu_ub), fill = alpha(palette[4], .7)) +
    geom_ribbon(aes(ymin = temp_hat_lb, ymax = temp_hat_ub), fill = alpha(palette[4], .4)) +
    geom_line(aes(y = temp_hat_p), colour = palette[7]) +
    theme_burgyl() +
    ggtitle("Posterior prediction check",
            "Fitting temperature to a 15 knotted cubic spline of year")

Actually, brms can using the s or t2 functions from the mgcv package to accomplish the same thing.

mu = as_data_frame(fitted(fit.spline.2))
temp_hat = as_data_frame(predict(fit.spline.2))

data_frame(
  temp = filter(d, !is.na(temp))$temp,
  year = filter(d, !is.na(temp))$year,
  temp_mu = mu$Estimate,
  temp_mu_lb = mu$Q2.5,
  temp_mu_ub = mu$Q97.5,
  temp_hat_p = temp_hat$Estimate,
  temp_hat_lb = temp_hat$Q2.5,
  temp_hat_ub = temp_hat$Q97.5) %>% 
  ggplot(aes(x = year, y = temp)) +
    geom_jitter(alpha = .4, colour = palette[6]) +
    geom_ribbon(aes(ymin = temp_mu_lb, ymax = temp_mu_ub), fill = alpha(palette[4], .7)) +
    geom_ribbon(aes(ymin = temp_hat_lb, ymax = temp_hat_ub), fill = alpha(palette[4], .4)) +
    geom_line(aes(y = temp_hat_p), colour = palette[7]) +
    theme_burgyl() +
    ggtitle("Posterior prediction check",
            "Fitting temperature to a 15 knotted cubic spline of year")

On transformations

Centering and scaling a continuous variable increases interpretability. Demeaning a predictor variable subtracts every value by it’s mean. By demeaning a predictor variables, the intercept represents the value of the outcome when all variables are at their mean. One standardizes a variable by dividing every value by the variables standard deviation. Standardizing causes the interpretation of coefficients to be in terms of unit changes in SD of the variable.

Log transforming the outcome variable makes y our coefficients represent percent increases in the outcome. Log transforming a predictor variable describes how a single percentage point increase in the predictor affects y. Log transforming both the predictor and outcome describes how percentage changes in one create percentage changes in the other.

Homework

Medium

4M1

For the model definition below, simulate observed heights from the prior.

num_observations <- 1e4

prior_mean <- rnorm(num_observations, 0, 10)
prior_sd <- runif(num_observations, 0, 10)

prior_heights <- rnorm(num_observations, prior_mean, prior_sd)

qplot(prior_heights)

4M2

model <- alist(
  y ~ dnorm(mu, sigma),
  mu ~ dnorm(0, 10),
  sigma ~ dunif(0, 10)
)

Hard

4H1

data("Howell1")
d <- Howell1
d$weight <- standardize(d$weight)
d

model <- map(
  alist(
    height ~ dnorm(mu, sigma),
    mu <- a + b * weight,
    a ~ dnorm(mean = 0, sd = 100),
    b ~ dnorm(mean = 0, sd = 10),
    sigma ~ dunif(min = 0, max = 64)
  ),
  data = d
)
model

# Standardize our input
new_weights <- standardize(c(46.95, 43.72, 64.78, 32.59, 54.63))

# Draw parameter values from the posterior distribution
posterior_samples <- extract.samples(model)

# Function to calculate fit heights
simulate_heights <- function(weight, parameter_samples) {
  rnorm(
    n = nrow(parameter_samples),
    mean = parameter_samples$a + parameter_samples$b * weight,
    sd = parameter_samples$sigma)}

# Generate a prediction for each new weight
# Use every parameter set in the posterior to do so
simulated_heights <- purrr::map(new_weights, ~ simulate(.x, posterior_samples))

data_frame(
  individual = 1:5,
  weight = c(46.95, 43.72, 64.78, 32.59, 54.63),
  expected_height = map_dbl(simulated_heights, mean),
  lower_pi = map_dbl(simulated_heights, ~PI(.x)[1]),
  upper_pi = map_dbl(simulated_heights, ~PI(.x)[2])
)

4H2

data("Howell1")
d <- Howell1
d %>% 
  filter(age < 18) %>% 
  ggplot(aes(x = weight, y = height)) +
  geom_point() + geom_smooth(method=lm) +
  geom_smooth(colour = "orange")

d %>% 
  filter(age < 18) %>% 
  map(alist(
    height ~ dnorm(mu, sigma),
    mu <- a + b * weight,
    a ~ dnorm(mean = 100, sd = 100),
    b ~ dnorm(mean = 0, sd = 10),
    sigma ~ dunif(min = 0, max = 50)
  ),
  data = .) ->
model

precis(model)

A one unit increase in weight increases height by 2.72, therefore a 10 unit increase will move height by 27.2.

# Sample the poseterior
posterior_samples <- extract.samples(model)

# Create x-axis
new_weights <- seq(from = 4, to = 45, length.out = 100)

# Calculate the mean
fn_mean <- function(weight) {posterior_samples$a + posterior_samples$b * weight}
fit_means <- purrr::map(new_weights, fn_mean)

# Calculate heights
fn_height <- function(weight) {
  rnorm(
    n = nrow(posterior_samples),
    mean = posterior_samples$a + posterior_samples$b * weight,
    sd = posterior_samples$sigma)
}
fit_heights <- purrr::map(new_weights, fn_height)

data_frame(
  weights = new_weights,
  means = map_dbl(fit_means, mean),
  means_low = map_dbl(fit_means, ~ HPDI(.x, .89)[1]),
  means_high = map_dbl(fit_means, ~ HPDI(.x, .89)[2]),
  heights = map_dbl(fit_heights, mean),
  heights_low = map_dbl(fit_heights, ~ HPDI(.x, .89)[1]),
  heights_high = map_dbl(fit_heights, ~ HPDI(.x, .89)[2]),
) %>% 
ggplot(aes(x = weights)) +
  geom_line(aes(y = means)) +
  geom_ribbon(aes(ymin = means_low, ymax = means_high), alpha = .4) +
  geom_ribbon(aes(ymin = heights_low, ymax = heights_high), alpha = .2) +
  geom_point(inherit.aes = FALSE, data = filter(d, age < 18),
             aes(x=weight, y = height), shape = 1) +
  ylab("height") + xlab("weight") + theme_bw() +
  theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank())

BRMS

data(Howell1)
d <- Howell1
d2 <- d %>% 
  filter(age >= 18)
d2 %>% 
  skim

library(brms)

b4.1 <-
  brm(data = d2, family = gaussian,
      height ~ 1,
      prior = c(prior(normal(178, 20), class = Intercept),
                prior(cauchy(0, 1), class = sigma)),
      iter = 31000, warmup = 30000, chains = 4, cores = 4)
plot(b4.1)

Extract variance covariance matrix.

# Extract samples from the posterior
post <- posterior_samples(b4.1)
# Covariance matrix
cov(post[, 1:2])

Lets extract the HDPI

library(tidybayes)

post %>% 
  select(-lp__) %>% 
  gather(parameter) %>% 
  group_by(parameter) %>% 
  median_hdi(value)

Now lets add a predictor.

d3 <- d2 %>% 
  mutate(weight = (weight - mean(weight))/sd(weight)) %>% 
  select(height, weight)

b4.3 <- 
  brm(data = d3, family = gaussian,
      height ~ 1 + weight,
      prior = c(prior(normal(156, 100), class = Intercept),
                prior(normal(0, 10), class = b),
                prior(uniform(0, 50), class = sigma)),
      iter = 46000, warmup = 45000, chains = 4, cores = 4,
      control = list(adapt_delta = 0.8, 
                     max_treedepth = 10))

plot(b4.3)

Examine covariance

pairs(b4.3)

Creating predictions

post <- posterior_samples(b4.3)

mu_at_50 <-
  post %>% 
  transmute(mu_at_50 = b_Intercept + b_weight * 50)

mu_at_50 %>%
  ggplot(aes(x = mu_at_50)) +
  geom_density(size = 0, fill = "grey75") +
  stat_pointintervalh(aes(y = 0), 
                      point_interval = mode_hdi, .width = .95) +
  scale_y_continuous(NULL, breaks = NULL) +
  labs(x = expression(mu["height | weight = 50"])) +
  theme_classic()

Now we extract complete predictions including the mean and added variance.

weight_seq <- tibble(weight = seq(from = 25, to = 70, by = 1))

pred_height <-
  predict(b4.3,
          newdata = weight_seq) %>%
  as_tibble() %>%
  bind_cols(weight_seq)
  
pred_height %>%
  slice(1:6)

ggplot(pred_height, aes(weight, Estimate)) +
  geom_ribbon(aes(ymin = Q2.5, ymax = Q97.5), fill = "grey75") +
  geom_line() +
  theme(panel.grid = element_blank())

We can overlay this with the mean interval too

mu_summary <-
  fitted(b4.3, 
         newdata = weight_seq) %>%
  as_tibble() %>%
  bind_cols(weight_seq)

ggplot(mu_summary, aes(weight, Estimate)) +
  geom_ribbon(aes(ymin = Q2.5, ymax = Q97.5), fill = "grey75") +
  geom_line() +
  theme(panel.grid = element_blank())

inner_join(pred_height, mu_summary, by = "weight", suffix=c("_height", "_mean")) %>% str

inner_join(pred_height, mu_summary, by = "weight", suffix=c("_height", "_mean")) %>% 
  ggplot(aes(x = weight, y = Estimate_height)) +
  geom_ribbon(aes(ymin = Q2.5_height, ymax = Q97.5_height), fill = "grey25") +
  geom_ribbon(aes(ymin = Q2.5_mean, ymax = Q97.5_mean), fill = "grey45") +
  geom_line() +
  theme(panel.grid = element_blank())

---
title: "Chapter 4 - Linear Models"
output: html_notebook
---

```{r message=FALSE, warning=FALSE}
library(tidyverse)
library(skimr)
library(rethinking)
```

# Notes

## Introduction
Linear regression describes a measurements mean and variance as the addition of other measurements. It assumes the errors in the primary measurement are of the gaussian distribution.

## Normality

1000 individuals conduct a random walk on either side of the football field starting at the 50 yard line (value = 0). This signifies the normal distribution.
```{r fig.width=14}
INDIVIDUALS <- 1000
TRIALS <- 100

purrr::map(1:INDIVIDUALS, ~ runif(TRIALS, -1, 1)) %>% 
  purrr::map(cumsum) %>% 
  reduce(rbind) %>% 
  as_tibble %>% 
  `colnames<-`(paste0(1:TRIALS, "t")) %>% 
  mutate(individual = row_number()) %>% 
  reshape2::melt("individual") %>% 
  arrange(individual, variable) %>% 
  ggplot(aes(x=variable, y=value, group=individual)) + 
    geom_line(alpha = I(1/20), size=1) +
    geom_boxplot(aes(x=variable, y = value), inherit.aes = FALSE, colour = "yellow", alpha= I(1/40))
```

The above example shows us that normality is additive. 
```{r}
# Generate 12 numbers between 1 and 1.1 then add them in to one sum
# Do this 1000 times and collect the numbers in a vector
growth <- replicate(1000, sum(runif(12,0,.1)))
# Plot the distribution of thes enumbers. Note that it is normal.
qplot(growth)
```

We can also show that normality is multiplicative.
```{r}
# Generate 12 numbers between 1 and 1.1 then multiply them in to one product
# Do this 1000 times and collect the numbers in a vector
growth <- replicate(1000, prod(1 + runif(12,0,.1)))
#plot the distribution of these numbers. Note that it is normal.
qplot(INDIVIDUALS)
```

Things start to skew at very large deviates, though this can be corrected by log scaling.
```{r }
big <- replicate(10000, prod(1 + runif(12, 0, .5)))
small <- replicate(10000, prod(1 + runif(12, 0, 0.01)))

data_frame(big = big, 
           small = small, 
           log_big = log(big)) %>% 
  gather %>% 
  ggplot(aes(value)) + 
    geom_histogram() + 
    facet_wrap("key", scales = "free")
```

## A language for describing models

Elements:

1. **An outcome variable**: The set of measurements we hope to predict or understand
2. **Likeliehood distribution**: For each of these outcome variables, we define the plausibility of that observations.
3. **Predictor variables**: Set of other measurements that we hope to use to predict or understand the outcome.

Approach:

1. Relate the exact shape of the likelihood distribution to the predictor variables via parameters
2. Choose priors for all the parameters in the model.


## Example: A gaussian model of height

We'll build a regression to predict a human's hight, which we will model as a Gaussian distribution with two parameters, mean and standard deviation. There are an infinite number of possible Gaussian distributions. We want our Bayesian machine to consider every possible distribution, each defined by a combination of meand and sd, and rank them by posterior plausibility given the data.

```{r}
data(Howell1)
d <- Howell1
d2 <- d %>% 
  filter(age >= 18)
d2 %>% 
  skim
```

Lets specifiy our model like so. The first line is the likelihood of our outcome, height. The second two lines are priors for the parameters in our likelihood.
$$
h_i \sim Normal(\mu, \sigma) \\
\mu \sim Normal(178, 20) \\
\sigma \sim Uniform(0, 50)
$$

As height is a physical phenomenon, we can use our intuition to assign a prior.
```{r}
data_frame(x=100:250, 
           y=purrr::map_dbl(100:250, ~ dnorm(.x, 178, 20))) %>% 
  ggplot(aes(x,y)) + geom_path()
```

We give the standard deviation a truly flat prior. We really just want to make sure its positive.
```{r}
data_frame(x=-10:60, 
           y=purrr::map_dbl(-10:60, ~ dunif(.x, 0, 50))) %>% 
  ggplot(aes(x,y)) + geom_path()
```

Specifying a prior for the parameters of our outcome implicitly give us a prior for our outcome.
```{r}
sample_mu <- rnorm(1e4, 178, 20)
sample_sigma <- runif(1e4, 0, 50)
prior_h <- rnorm(1e4, sample_mu, sample_sigma)
qplot(prior_h)
```

Lets us grid approximation to generate the posterior. To do so, we enumerate a list of candidate values for our parameters and store them in post. We then calculate the log likelihood for each of those parameters given all the heights we have seen and store them in the column LL. We use log transformation to avoid rounding errors. Then we multiply by the priors (log addition is the same as multiplying)
```{r}
# Generate candidate parameters
mu_list <- seq(from=140, to=160, length.out=200)
sigma_list <- seq(from=4, to=9, length.out=200)
post <- expand.grid(mu=mu_list, sigma=sigma_list)

# Calculate the likelihood of every possible
# combination candidate parameters
post$LL <- sapply(1:nrow(post), function(i) {
  sum(dnorm(
    d2$height,
    mean=post$mu[i],
    sd=post$sigma[i],
    log=TRUE))
  })

# Multiply priors
post$prod <- post$LL + dnorm(post$mu, 178, 20, TRUE) +
  dunif(post$sigma, 0, 50, TRUE)

# Calculated scaled posterior
post$prob <- exp(post$prod - max(post$prod))

# Contour plot of probabilities
ggplot(post, aes(x=mu, y=sigma, z=prob)) + 
  geom_contour(aes(colour=stat(level))) + 
  coord_cartesian(xlim=c(140, 160), ylim=c(4, 9))
```

Now lets sample from the posterior.
```{r}
# Sample candidate values by posterior
sample_rows <- sample(1:nrow(post), size=1e4, replace=TRUE, prob=post$prob)

# Plot their 2d histogram
data_frame(
  sample_mu = post$mu[sample_rows],
  sample_sigma = post$sigma[sample_rows]
) %>% 
  ggplot(aes(sample_mu, sample_sigma)) +
    geom_bin2d(bins=30) + 
    coord_cartesian(xlim=c(140, 160), ylim=c(4, 9))
```

Lets also examine the margins.
```{r}
require(gridExtra)

p1 <- post$mu[sample_rows] %>% 
  qplot + ggtitle("mu")
p2 <- post$sigma[sample_rows] %>% 
  qplot + ggtitle("sigma")

grid.arrange(p1, p2, ncol=2)
```

`map` from the rethinking package allows us to solve for the posterior using quadratic approximation instead of grid approximations. It shows us gaussian approximations for each parameter's marginal distribution.
```{r}
flist <- alist(
  height ~ dnorm(mu, sigma),
  mu ~ dnorm(178, 20),
  sigma ~ dunif(0, 50)
)
m4.1 <- rethinking::map(flist, data=d2)
precis(m4.1)
```

Variance covariance matrix tells us how each parameter relates to every other parameter in the posterior distribution.
```{r}
vcov(m4.1)
# This can be factored in to a vector of variances
diag(vcov(m4.1))
# Or a correlation matrix
cov2cor(vcov(m4.1))
```

Lets draw from the posterior by sampling vectors of values from a multi-dimensional gaussian distribution.
```{r}
post <- extract.samples(m4.1, n=1e4)
precis(post)
```

### Adding a predictor variable, weight

It looks like weight will be a good predictor for height in adults.
```{r}
ggplot(d2, aes(x=weight, y=height)) + 
  geom_point(shape=1) +
  geom_smooth(method=lm)
```

The goal here is to make the parameter for the mean of a Gaussian distribution, $\mu$, into a linear function of the predictor variable. This encodes the assumption that the predictor variable has a perfectly constant and additive relationship to the mean of the outcome.
```{r}
m4.3 <- rethinking::map(
  alist(
    height ~ dnorm(mu, sigma),
    mu <- a + b*weight,
    a ~ dnorm(156, 100),
    b ~ dnorm(0, 10),
    sigma ~ dunif(0, 50)),
  data = d2)
# Display table of estimates
precis(m4.3, corr=TRUE)
```

The table above tells us that a person 1 kg heavier is expected to be .9 cm taller. It also tells us that a person with 0 weight is 114 cm tall, which is of course nonsense; This is why it is usually important to have very weak priors for intercepts in many cases. Finally, it explains that 95% of plausible heights lie within 10 cm of the mean.

Centering is the procedure of subtracting the mean of a variable from each value. 
```{r}
d2$weight.c <- d2$weight - mean(d2$weight)

m4.4 <- rethinking::map(
  alist(
    height ~ dnorm(mu, sigma),
    mu <- a + b*weight.c,
    a ~ dnorm(178, 100),
    b ~ dnorm(0, 10),
    sigma ~ dunif(0, 50)),
  data = d2)
# Display table of estimates
precis(m4.4, corr=TRUE)
```

By **centering** our predictor variable, the interpretation of the intercept has now become the expected value of the outcome when the predictor is at its average value. This makes interpreting the intercept a lot easier. 

### Visualizing our estimates

We can plot our maximum a posteriori fit here

```{r}
p <- ggplot(d2, aes(x=weight, y=height)) +
  geom_point(shape=1, size=2) +
  geom_abline(aes(intercept = coef(m4.3)["a"],
                  slope = coef(m4.3)["b"]))
p
```

This line only represents one piece of the posterior. We could instead sample values of $\alpha$ and $\beta$ from the posterior to generate many lines to build bounds of uncertainty. We'll do this with a much smaller dataset to magnify effects.
```{r}
N <- 10
dN <- d2[ 1:N , ]
mN <- rethinking::map(
  alist(
    height ~ dnorm( mu , sigma ) ,
    mu <- a + b*weight ,
    a ~ dnorm( 178 , 100 ) ,
    b ~ dnorm( 0 , 10 ) ,
    sigma ~ dunif( 0 , 50 )
) , data=dN )

post <- extract.samples(mN, n=20)
head(post)
```

```{r}
p <- ggplot(dN, aes(weight, height)) +
  geom_point(shape=1)

for (i in 1:20) {
  p <- p + geom_abline(intercept = post$a[i], slope = post$b[i], alpha = I(3/10))
}

p
```

To do this more generally:

1. Sample parameter values from the posterior.
2. Use the parameter values to create predictions of the parameters of interest, including the final outcome.
3. Use summary functions like mean, HDOP, PI to find averages and lower and upper bounds of our uncertainty.


```{r}
# Draw parameter values from the posterior distribution
posterior_samples <- extract.samples(m4.3)

# Create out x-axis of interest
weights_axis <- 25:70

# Function to calculate fit values for \mu
mu_link <- function(weight) post$a + post$b*weight
mu <- purrr::map(weights_axis, mu_link)

# Function to calculate fit heights
# This incorporates variability as well
simulate <- function(weight, parameter_samples) {
  rnorm(n = nrow(parameter_samples),
        mean = parameter_samples$a + parameter_samples$b * weight,
        sd = parameter_samples$sigma)}
simulated_heights <- purrr::map(weights_axis, ~ simulate(.x, posterior_samples))

# Combine all this information to plot
data_frame(
  # X axis
  weight = weights_axis,
  # Estimates for mean height
  mu_mean = map_dbl(mu, mean),
  mu_lower = map_dbl(mu, ~HPDI(.x, .89)[1]),
  mu_upper = map_dbl(mu, ~HPDI(.x, .89)[2]),
  # Estimates for height
  height_mean = map_dbl(simulated_heights, mean),
  height_low = map_dbl(simulated_heights, ~HPDI(.x, .89)[1]),
  height_high = map_dbl(simulated_heights, ~HPDI(.x, .89)[2])) %>% 
  ggplot(data=.) +
  geom_point(inherit.aes = FALSE, data = d2,
             aes(x=weight, y=height), shape=1) +
  geom_line(aes(x=weight, y=mu_mean)) +
  geom_ribbon(aes(x = weight, ymin=mu_lower, ymax=mu_upper), alpha=.5) +
  geom_ribbon(aes(x = weight, ymin = height_low, ymax = height_high), alpha=.3) +
  ggtitle("The effect of weight on height", subtitle = "Using 89% highest posterior density intervals") +
  coord_cartesian(xlim=c(30, 60),ylim=c(135, 180))
```

## Polynomial Regression

Standardizing our predictors means scaling but also dividing by the standard deviation. This changes our interpretation of continuous variables to mean the unit change in outcome from a cahnge of one standard deviation. 

```{r}
# Standardize continuous variable
standardize <- function(vec) {
  centered <- vec - mean(vec)
  centered / sd(vec)
}
d$weight.s <- standardize(d$weight)

# Define another polynomial term
d$weight.s2 <- d$weight.s^2

m4.5 <- map(
  alist(
    # Outcome
    height ~ dnorm(mu, sigma),
    # Regression specification
    mu <- a + b1*weight.s + b2*weight.s2,
    a ~ dnorm(178 , 100),
    # These priors are very weak!
    b1 ~ dnorm(0 , 10),
    b2 ~ dnorm(0 , 10),
    sigma ~ dunif(0 , 50)),
  data=d )
precis( m4.5 )
```

## B-Splines
Splines are an alternative to modeling non-linearity. We'll show this with some cherry blossom data.
```{r}
library(rethinking)
library(rcartocolor)
colour_theme <- "BurgYl"
palette <- carto_pal(7, colour_theme)

data(cherry_blossoms)
d <- cherry_blossoms

d %>% 
  select(year, temp) %>% 
  ggplot(aes(year, temp)) +
    geom_line(colour = palette[7]) +
    theme_burgyl()
    
```

Splines work by defining knot points and fitting local models between them. A common way to pick these knot points is to evenly space them across the probability density of the variable. Cross validation can ultimately be used to validate the number and spacing.
```{r}
d2 <- d %>% 
  filter(!is.na(temp))
num_knots <- 15
knot_list <- quantile(d2$year, probs = seq(0, 1, length.out = num_knots))
d2 %>% 
  ggplot(aes(year)) +
  geom_density(colour = "transparent", fill = palette[5]) +
  geom_point(data = data_frame(y= rep(0, length(knot_list)), x=knot_list),
             mapping = aes(x, y), 
             size = 3, colour = palette[7]) +
  theme_burgyl() + ggtitle("Knot point allocation")
```

Now we pick the polynomial degree. This determines how many basis parameters at once are interacting with a given point. The `splines` library in R can help us with this. The code below will create 17 columns in place of year that result from its change of basis.
```{r}
library(splines)
library(brms)

# Split year in to basis function
B <- bs(d2$year,
        knots = knot_list[-c(1, num_knots)],
        degree = 3, intercept = TRUE) %>% 
  as_data_frame %>% 
  set_names(., paste0("year_",names(.)))

# Bind to original data frame
d3 <- d2 %>% 
  select(temp) %>% 
  bind_cols(B)
d3 %>% glimpse

fit.spline <- brm(temp ~ ., family = gaussian(), data = d3,
                  prior = c(prior(normal(6, 10), class = Intercept),
                            prior(normal(0, 1), class = b),
                            prior(exponential(1), class = sigma)),
                  refresh = 0)
posterior_summary(fit.spline)
```

Extract the predicted means and the error term.
```{r}
mu = as_data_frame(fitted(fit.spline))
temp_hat = as_data_frame(predict(fit.spline))

(dimensions <- list(mu = dim(mu), 
                   temp_hat = dim(temp_hat)))
```

Plot the posterior predictions.
```{r}
data_frame(
  temp = filter(d, !is.na(temp))$temp,
  year = filter(d, !is.na(temp))$year,
  temp_mu = mu$Estimate,
  temp_mu_lb = mu$Q2.5,
  temp_mu_ub = mu$Q97.5,
  temp_hat_p = temp_hat$Estimate,
  temp_hat_lb = temp_hat$Q2.5,
  temp_hat_ub = temp_hat$Q97.5) %>% 
  ggplot(aes(x = year, y = temp)) +
    geom_jitter(alpha = .4, colour = palette[6]) +
    geom_ribbon(aes(ymin = temp_mu_lb, ymax = temp_mu_ub), fill = alpha(palette[4], .7)) +
    geom_ribbon(aes(ymin = temp_hat_lb, ymax = temp_hat_ub), fill = alpha(palette[4], .4)) +
    geom_line(aes(y = temp_hat_p), colour = palette[7]) +
    theme_burgyl() +
    ggtitle("Posterior prediction check",
            "Fitting temperature to a 15 knotted cubic spline of year")
```

Actually, brms can using the `s` or `t2` functions from the `mgcv` package to accomplish the same thing.
```{r}
fit.spline.2 <- brm(temp ~ s(year, k = 15), # 15 knots
                    data = d2, family = gaussian(),
                    prior = c(prior(normal(6, 10), class = Intercept),
                            prior(normal(0, 1), class = b),
                            prior(exponential(1), class = sigma)))

mu = as_data_frame(fitted(fit.spline.2))
temp_hat = as_data_frame(predict(fit.spline.2))

data_frame(
  temp = filter(d, !is.na(temp))$temp,
  year = filter(d, !is.na(temp))$year,
  temp_mu = mu$Estimate,
  temp_mu_lb = mu$Q2.5,
  temp_mu_ub = mu$Q97.5,
  temp_hat_p = temp_hat$Estimate,
  temp_hat_lb = temp_hat$Q2.5,
  temp_hat_ub = temp_hat$Q97.5) %>% 
  ggplot(aes(x = year, y = temp)) +
    geom_jitter(alpha = .4, colour = palette[6]) +
    geom_ribbon(aes(ymin = temp_mu_lb, ymax = temp_mu_ub), fill = alpha(palette[4], .7)) +
    geom_ribbon(aes(ymin = temp_hat_lb, ymax = temp_hat_ub), fill = alpha(palette[4], .4)) +
    geom_line(aes(y = temp_hat_p), colour = palette[7]) +
    theme_burgyl() +
    ggtitle("Posterior prediction check",
            "Fitting temperature to a 15 knotted cubic spline of year")

```


## On transformations

Centering and scaling a continuous variable increases interpretability. Demeaning a predictor variable subtracts every value by it's mean. By demeaning a predictor variables, the intercept represents the value of the outcome when all variables are at their mean. One standardizes a variable by dividing every value by the variables standard deviation. Standardizing causes the interpretation of coefficients to be in terms of unit changes in SD of the variable.


Log transforming the outcome variable makes y our coefficients represent percent increases in the outcome. Log transforming a predictor variable describes how a single percentage point increase in the predictor affects y. Log transforming both the predictor and outcome describes how percentage changes in one create percentage changes in the other.


# Homework

## Medium
### 4M1
For the model definition below, simulate observed heights from the prior.
```{r}
num_observations <- 1e4

prior_mean <- rnorm(num_observations, 0, 10)
prior_sd <- runif(num_observations, 0, 10)

prior_heights <- rnorm(num_observations, prior_mean, prior_sd)

qplot(prior_heights)
```


### 4M2
```{r}
model <- alist(
  y ~ dnorm(mu, sigma),
  mu ~ dnorm(0, 10),
  sigma ~ dunif(0, 10)
)
```



## Hard
### 4H1
```{r}
data("Howell1")
d <- Howell1
d$weight <- standardize(d$weight)
d
```


```{r}
model <- map(
  alist(
    height ~ dnorm(mu, sigma),
    mu <- a + b * weight,
    a ~ dnorm(mean = 0, sd = 100),
    b ~ dnorm(mean = 0, sd = 10),
    sigma ~ dunif(min = 0, max = 64)
  ),
  data = d
)
model
```

```{r}
# Standardize our input
new_weights <- standardize(c(46.95, 43.72, 64.78, 32.59, 54.63))

# Draw parameter values from the posterior distribution
posterior_samples <- extract.samples(model)

# Function to calculate fit heights
simulate_heights <- function(weight, parameter_samples) {
  rnorm(
    n = nrow(parameter_samples),
    mean = parameter_samples$a + parameter_samples$b * weight,
    sd = parameter_samples$sigma)}

# Generate a prediction for each new weight
# Use every parameter set in the posterior to do so
simulated_heights <- purrr::map(new_weights, ~ simulate(.x, posterior_samples))

data_frame(
  individual = 1:5,
  weight = c(46.95, 43.72, 64.78, 32.59, 54.63),
  expected_height = map_dbl(simulated_heights, mean),
  lower_pi = map_dbl(simulated_heights, ~PI(.x)[1]),
  upper_pi = map_dbl(simulated_heights, ~PI(.x)[2])
)
```

# 4H2
```{r}
data("Howell1")
d <- Howell1
d %>% 
  filter(age < 18) %>% 
  ggplot(aes(x = weight, y = height)) +
  geom_point() + geom_smooth(method=lm) +
  geom_smooth(colour = "orange")
```

```{r}
d %>% 
  filter(age < 18) %>% 
  map(alist(
    height ~ dnorm(mu, sigma),
    mu <- a + b * weight,
    a ~ dnorm(mean = 100, sd = 100),
    b ~ dnorm(mean = 0, sd = 10),
    sigma ~ dunif(min = 0, max = 50)
  ),
  data = .) ->
model

precis(model)
```

A one unit increase in weight increases height by 2.72, therefore a 10 unit increase will move height by 27.2.

```{r}
# Sample the poseterior
posterior_samples <- extract.samples(model)

# Create x-axis
new_weights <- seq(from = 4, to = 45, length.out = 100)

# Calculate the mean
fn_mean <- function(weight) {posterior_samples$a + posterior_samples$b * weight}
fit_means <- purrr::map(new_weights, fn_mean)

# Calculate heights
fn_height <- function(weight) {
  rnorm(
    n = nrow(posterior_samples),
    mean = posterior_samples$a + posterior_samples$b * weight,
    sd = posterior_samples$sigma)
}
fit_heights <- purrr::map(new_weights, fn_height)

data_frame(
  weights = new_weights,
  means = map_dbl(fit_means, mean),
  means_low = map_dbl(fit_means, ~ HPDI(.x, .89)[1]),
  means_high = map_dbl(fit_means, ~ HPDI(.x, .89)[2]),
  heights = map_dbl(fit_heights, mean),
  heights_low = map_dbl(fit_heights, ~ HPDI(.x, .89)[1]),
  heights_high = map_dbl(fit_heights, ~ HPDI(.x, .89)[2]),
) %>% 
ggplot(aes(x = weights)) +
  geom_line(aes(y = means)) +
  geom_ribbon(aes(ymin = means_low, ymax = means_high), alpha = .4) +
  geom_ribbon(aes(ymin = heights_low, ymax = heights_high), alpha = .2) +
  geom_point(inherit.aes = FALSE, data = filter(d, age < 18),
             aes(x=weight, y = height), shape = 1) +
  ylab("height") + xlab("weight") + theme_bw() +
  theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank())
```

# BRMS

```{r}
data(Howell1)
d <- Howell1
d2 <- d %>% 
  filter(age >= 18)
d2 %>% 
  skim
```


```{r}
library(brms)

b4.1 <-
  brm(data = d2, family = gaussian,
      height ~ 1,
      prior = c(prior(normal(178, 20), class = Intercept),
                prior(cauchy(0, 1), class = sigma)),
      iter = 31000, warmup = 30000, chains = 4, cores = 4)
plot(b4.1)
```

Extract variance covariance matrix.
```{r}
# Extract samples from the posterior
post <- posterior_samples(b4.1)
# Covariance matrix
cov(post[, 1:2])
```

Lets extract the HDPI
```{r}
library(tidybayes)

post %>% 
  select(-lp__) %>% 
  gather(parameter) %>% 
  group_by(parameter) %>% 
  median_hdi(value)
```

Now lets add a predictor.
```{r message=FALSE, warning=FALSE}
d3 <- d2 %>% 
  mutate(weight = (weight - mean(weight))/sd(weight)) %>% 
  select(height, weight)

b4.3 <- 
  brm(data = d3, family = gaussian,
      height ~ 1 + weight,
      prior = c(prior(normal(156, 100), class = Intercept),
                prior(normal(0, 10), class = b),
                prior(uniform(0, 50), class = sigma)),
      iter = 46000, warmup = 45000, chains = 4, cores = 4,
      control = list(adapt_delta = 0.8, 
                     max_treedepth = 10))

plot(b4.3)
```

Examine covariance
```{r}
pairs(b4.3)
```

Creating predictions
```{r}
post <- posterior_samples(b4.3)

mu_at_50 <-
  post %>% 
  transmute(mu_at_50 = b_Intercept + b_weight * 50)

mu_at_50 %>%
  ggplot(aes(x = mu_at_50)) +
  geom_density(size = 0, fill = "grey75") +
  stat_pointintervalh(aes(y = 0), 
                      point_interval = mode_hdi, .width = .95) +
  scale_y_continuous(NULL, breaks = NULL) +
  labs(x = expression(mu["height | weight = 50"])) +
  theme_classic()

```

Now we extract complete predictions including the mean and added variance.
```{r}
weight_seq <- tibble(weight = seq(from = 25, to = 70, by = 1))

pred_height <-
  predict(b4.3,
          newdata = weight_seq) %>%
  as_tibble() %>%
  bind_cols(weight_seq)
  
pred_height %>%
  slice(1:6)
```

```{r}
ggplot(pred_height, aes(weight, Estimate)) +
  geom_ribbon(aes(ymin = Q2.5, ymax = Q97.5), fill = "grey75") +
  geom_line() +
  theme(panel.grid = element_blank())
```

We can overlay this with the mean interval too
```{r}
mu_summary <-
  fitted(b4.3, 
         newdata = weight_seq) %>%
  as_tibble() %>%
  bind_cols(weight_seq)

ggplot(mu_summary, aes(weight, Estimate)) +
  geom_ribbon(aes(ymin = Q2.5, ymax = Q97.5), fill = "grey75") +
  geom_line() +
  theme(panel.grid = element_blank())
```

```{r}
inner_join(pred_height, mu_summary, by = "weight", suffix=c("_height", "_mean")) %>% str
```

```{r}
inner_join(pred_height, mu_summary, by = "weight", suffix=c("_height", "_mean")) %>% 
  ggplot(aes(x = weight, y = Estimate_height)) +
  geom_ribbon(aes(ymin = Q2.5_height, ymax = Q97.5_height), fill = "grey25") +
  geom_ribbon(aes(ymin = Q2.5_mean, ymax = Q97.5_mean), fill = "grey45") +
  geom_line() +
  theme(panel.grid = element_blank())
```













Chapter 4 - Linear Models